home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Moscow ML 1.42 / ANSIshellƒ / os_mac_eStyle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-18  |  23.1 KB  |  805 lines  |  [TEXT/R*ch]
  1. /* os_mac_eStyle.c
  2.  * 2Jun92  e
  3.  */
  4.  
  5. #ifdef THINK_C
  6. #include <MacHeaders>
  7. #else
  8. #ifdef __MWERKS__
  9. #else
  10. "Unknown compiler!"
  11. #endif
  12. #endif
  13.  
  14. /*
  15. #include <Dialogs.h>
  16. #include <Controls.h>
  17. #include <QuickDraw.h>
  18. #include <Windows.h>
  19. #include <ToolUtils.h>
  20. #include <OSUtils.h>
  21. #include <Menus.h>
  22. #include <Fonts.h>
  23. #include <resources.h>
  24. */
  25.  
  26. #include "os_mac.h"
  27.  
  28. /* extensions to an editor for text files by e
  29.    questions/comments via Internet <e@Flavors.COM>
  30. */
  31. /* Copyright © e 1992. All rights reserved.
  32.     Developed using THINK C 5.0.1 for use with Gambit Scheme.
  33.     This code may be freely distributed as long as this notice remains.
  34. */
  35.  
  36. /* to do:
  37. 06Jun92  e
  38. consider checkbox to modify OK to:
  39. - Set Style for All Windows
  40. consider showing text in style
  41. - (let ((the 3) (quick 5) (brown 7)) (fox jumps over the lazy dog))
  42. - ((lambda (the quick brown) (fox jumps over (the lazy) dog)) 3 5 7)
  43. consider a way to save Window's style in the file
  44. consider a way to save Creation style (preferences)
  45. add a Use Outline Fonts checkbox
  46. */
  47.  
  48. #define MAXFONTSIZE 1023
  49.  
  50. /* resources */
  51.  
  52. #define esdID        357
  53.  
  54. /* dialog items */
  55.  
  56. #define esdOK         1
  57. #define esdCancel     2
  58. #define esdTabsEt     3
  59. #define esdTabsSt     4
  60. #define esdFont1St     5
  61. #define esdFont1Pu     6
  62. #define esdSize1St     7
  63. #define esdSize1Et     8
  64. #define esdBold1Cb     9
  65. #define esdItal1Cb    10
  66. #define esdCond1Cb    11
  67. #define esdUndr1Cb    12
  68. #define esdInvr1Cb    13
  69. #define esdExpd1Cb    14
  70. #define esdFont2St    15
  71. #define esdFont2Pu    16
  72. #define esdSize2St    17
  73. #define esdSize2Et    18
  74. #define esdBold2Cb    19
  75. #define esdItal2Cb    20
  76. #define esdCond2Cb    21
  77. #define esdUndr2Cb    22
  78. #define esdInvr2Cb    23
  79. #define esdExpd2Cb    24
  80. #define esdPS1St    25
  81. #define esdPS2St    26
  82. #define esdSize1Pu    27
  83. #define esdSize2Pu    28
  84. #define esdOutline1    29
  85. #define esdOutline2    30
  86. #define esdOKring    31
  87. #define esdThisBt    32
  88. #define esdPrefBt    33
  89. #define esdDfltBt    34
  90. #define esdGetSt    35
  91. #define esdOutline3    36
  92. #define esdApplSt    37
  93. #define esdThisCb    38
  94. #define esdPrefCb    39
  95. #define esdWrapEt    40
  96. #define esdAutoInd    42
  97.  
  98. /* the pop-up font item */
  99.  
  100. /* See: Apple Macintosh Developer Technical Support
  101.         Pop-up Menu Example Application
  102.         PopMenus.p
  103. */
  104.  
  105. static TextStyle tsNewPri, tsNewAlt;
  106. static short tabsNew;
  107. static short wrapNew;
  108. static short autoIndNew;
  109.  
  110. #define popMenuID1 128
  111. static MenuHandle popMenu1;
  112. static Rect  popUpBox1;        /* boundsrect of font popUp1 */
  113. static Rect  promptBox1;    /* boundsrect of its title */
  114. static short fontChoice1;    /* its last chosen item */
  115.  
  116. #define popMenuID2 129
  117. static MenuHandle popMenu2;
  118. static Rect  popUpBox2;        /* boundsrect of font popUp2 */
  119. static Rect  promptBox2;    /* boundsrect of its title */
  120. static short fontChoice2;    /* its last chosen item */
  121.  
  122. #define popMenuID3 130
  123. static MenuHandle popMenu3;
  124. static Rect  popUpBox3;        /* boundsrect of font popUp2 */
  125. static short sizeChoice3;    /* its last chosen item */
  126.  
  127. #define popMenuID4 131
  128. static MenuHandle popMenu4;
  129. static Rect  popUpBox4;        /* boundsrect of font popUp2 */
  130. static short sizeChoice4;    /* its last chosen item */
  131.  
  132. /* some user item action procs -- used in update events mostly */
  133.  
  134. #define leftSlop 15
  135. #define rightSlop 17
  136. #define botSlop 5
  137.  
  138. static void drawPopArrow( Rect r )
  139. { 
  140.   FrameRect( &r );
  141.   MoveTo( r.right, r.top+2 );
  142.   LineTo( r.right, r.bottom );
  143.   LineTo( r.left+2, r.bottom );
  144.   MoveTo( r.right-17, r.top+6 );
  145.   Line( 11, 0 );
  146.   Move( -10, 1 );
  147.   Line( 9, 0 );
  148.   Move( -8, 1);
  149.   Line( 7, 0 );
  150.   Move( -6, 1);
  151.   Line( 5, 0 );
  152.   Move( -4, 1 );
  153.   Line( 3, 0 );
  154.   Move( -2, 1 );
  155.   Line( 1, 0 );
  156. }
  157.  
  158. static pascal void DrawPopUpSz( DialogPtr dwind, short dinum )
  159. { short itemtype;
  160.   Handle itemhandle;
  161.   Rect r;
  162.   GetDialogItem( dwind, dinum, &itemtype, &itemhandle, &r );
  163.   InsetRect( &r, -1, -1 );
  164.   drawPopArrow( r );
  165. }
  166.  
  167. static void DrawPopUpX( MenuHandle popMenu, Rect* popUpBox, short lastChoice )
  168. { Rect r;
  169.   Str255 curFont;
  170.   short newWid, newLen, wid;
  171.  
  172.   GetMenuItemText( popMenu, lastChoice, curFont ); /* get currently-selected item */
  173.   r = *popUpBox;
  174.   EraseRect( &r );
  175.   InsetRect( &r, -1, -1 );
  176.   /* Make sure the title fits. Truncate it and add an ellipses (“…”) otherwise */
  177.   wid = (r.right - r.left) - (leftSlop + rightSlop);
  178.   newWid = StringWidth( curFont );
  179.   if( newWid > wid )
  180.   { newLen = curFont[0]; /* current length in characters */
  181.     wid = wid - CharWidth('…');
  182.     do
  183.     { newWid = newWid - CharWidth( curFont[newLen--] );
  184.     } while( ( newWid > wid ) && ( newLen > 0 ) );
  185.     curFont[++newLen] = '…';
  186.     curFont[0] = newLen;
  187.   }
  188.   drawPopArrow( r );
  189.   MoveTo( r.left+leftSlop, r.bottom-botSlop);
  190.   DrawString( curFont );
  191. }
  192.  
  193. static pascal void DrawPopUp1( DialogPtr theDialog, short theItem )
  194. {
  195.  #pragma unused( theDialog, theItem )
  196.  DrawPopUpX( popMenu1, &popUpBox1, fontChoice1 );
  197. }
  198.  
  199. static pascal void DrawPopUp2( DialogPtr theDialog, short theItem )
  200. {
  201.  #pragma unused( theDialog, theItem )
  202.  DrawPopUpX( popMenu2, &popUpBox2, fontChoice2 );
  203. }
  204.  
  205. /* BorderDefault draws a heavy border around the default ( OK ) button */
  206. static pascal void BorderDefault( WindowPtr dwind, short dinum )
  207. {
  208.   #pragma unused( dinum )
  209.   short itemtype;
  210.   Handle itemhandle;
  211.   Rect borderRect;
  212.   GetDialogItem( dwind, esdOK, &itemtype, &itemhandle, &borderRect );
  213.   InsetRect( &borderRect, -4, -4 );
  214.   PenSize( 3, 3 );
  215.   FrameRoundRect( &borderRect, 16, 16 );
  216.   PenSize( 1, 1 );
  217. }
  218.  
  219. /* Outliner draws a light border around the the user item */
  220. static pascal void Outliner( WindowPtr dwind, short dinum )
  221. { short itemtype;
  222.   Handle itemhandle;
  223.   Rect borderRect;
  224.   GetDialogItem( dwind, dinum, &itemtype, &itemhandle, &borderRect );
  225.   /* InsetRect( &borderRect, -4, -4 ); */
  226.   PenSize( 1, 1 );
  227.   FrameRoundRect( &borderRect, 16, 16 );
  228. }
  229.  
  230. /* util fcns. */
  231.  
  232. /* cursor to IBeam if it's over an active edit line, arrow if it's not */
  233. void IBeamIt( WindowPtr dwind )
  234. { Point mouseAt;
  235.   short itemtype;
  236.   Handle itemhandle;
  237.   Rect borderRect;
  238.   short itemNum;
  239.   /* first get the current edit line out of the dialog record */
  240.   itemNum = ((DialogPeek )dwind)->editField + 1; /* always stored 1 less */
  241.   GetDialogItem( dwind, itemNum, &itemtype, &itemhandle, &borderRect );
  242.   GetMouse( &mouseAt );
  243.   if( PtInRect( mouseAt, &borderRect ) )
  244.     SetCursor(&ibeam_cursor);
  245.   else
  246.     SetCursor(&qd.arrow);
  247. }
  248.  
  249. static void pseudoClick( DialogPtr dbox, short item )
  250. { short itemtype;
  251.   Rect itemrect;
  252.   Handle hC;
  253.   long tilticks;
  254.   GetDialogItem( dbox, item, &itemtype, &hC, &itemrect );
  255.   HiliteControl( (ControlHandle)hC, kControlButtonPart ); // inButton
  256.   Delay( 8, &tilticks );
  257.   HiliteControl( (ControlHandle)hC, false );
  258. }
  259.  
  260. static short apndMenu( MenuHandle hM, Str255 title, short itemno, Boolean check, Boolean realfont )
  261. {
  262.   AppendMenu( hM, title );
  263.   if( realfont ) SetItemStyle( hM, itemno, outline );
  264.   if( check )
  265.   { SetItemMark( hM, itemno, checkMark );
  266.     return itemno;
  267.   }
  268.   return 0;
  269. }
  270.  
  271. static MenuHandle sizeMenu( short id, short *ckitem, short fNum, short curSize )
  272. { MenuHandle hM;
  273.   Str255 oddSize;
  274.   short match = 0;
  275.   hM = NewMenu( id, "\p" );
  276.   match |= apndMenu( hM,  "\p9", 1, (curSize ==  9), RealFont( fNum,  9 ) );
  277.   match |= apndMenu( hM, "\p10", 2, (curSize == 10), RealFont( fNum, 10 ) );
  278.   match |= apndMenu( hM, "\p12", 3, (curSize == 12), RealFont( fNum, 12 ) );
  279.   match |= apndMenu( hM, "\p14", 4, (curSize == 14), RealFont( fNum, 14 ) );
  280.   match |= apndMenu( hM, "\p18", 5, (curSize == 18), RealFont( fNum, 18 ) );
  281.   match |= apndMenu( hM, "\p24", 6, (curSize == 24), RealFont( fNum, 24 ) );
  282.   if( match == 0 )
  283.   { NumToString( (long )curSize, oddSize );
  284.     InsertMenuItem( hM, oddSize, 0 );
  285.     InsertMenuItem( hM, "\p(-", 1 );
  286.     SetItemMark( hM, 1, checkMark );
  287.     if( RealFont( fNum, curSize ) ) SetItemStyle( hM, 1, outline );
  288.     *ckitem = 1;
  289.   }
  290.   else *ckitem = match;
  291.   return( hM );
  292. }
  293.  
  294. static short doPop( DialogPtr esd, MenuHandle popMenu, Rect popUpBox, short id, short oldChoice )
  295. {
  296.   #pragma unused( esd )
  297.   long chosen;
  298.   Point popLoc;
  299.   short newChoice;
  300.   InsertMenu( popMenu, -1 );
  301.   popLoc = topLeft(popUpBox);
  302.   LocalToGlobal( &popLoc );
  303.   CalcMenuSize( popMenu ); /* Work around Menu Mgr bug */
  304.   chosen = PopUpMenuSelect( popMenu, popLoc.v, popLoc.h, oldChoice );
  305.   DeleteMenu( id );
  306.   if( chosen != 0 )
  307.   { newChoice = LoWord(chosen);
  308.     if( newChoice != oldChoice )
  309.     { SetItemMark( popMenu, oldChoice, ' ' );
  310.       SetItemMark( popMenu, newChoice, checkMark );
  311.       EraseRect( &popUpBox );
  312.       return( newChoice );
  313.     }
  314.   }
  315.   return 0;
  316. }
  317.  
  318. /* filter proc */
  319.  
  320. #define kReturnKey 0x0D
  321. #define kEnterKey 0x03
  322. #define kEscKey 0x1B
  323. #define kTabKey 9
  324. enum  {
  325.     kBackSpace = 8,
  326.     kLeftArrow = 0x1C, kRightArrow, kUpArrow, kDownArrow,
  327.     kDeleteKey = 0x7F
  328. };
  329.  
  330. /* size menu selection => edit text box */
  331. static void doSize1( DialogPtr esd )
  332. { Rect tempRect;
  333.   short tempItem;
  334.   Handle tempHandle;
  335.   long tmp;
  336.   Str255 tStr;
  337.   GetDialogItem( esd, esdSize1Et, &tempItem, &tempHandle, &tempRect );
  338.   GetMenuItemText( popMenu3, sizeChoice3, tStr );
  339.   SetDialogItemText( tempHandle, tStr );
  340.   SelectDialogItemText( esd, esdSize1Et, 0, 32767 );
  341.   StringToNum( tStr, &tmp);
  342.   tsNewPri.tsSize = tmp;
  343. }
  344.  
  345. /* size menu selection => edit text box */
  346. static void doSize2( DialogPtr esd )
  347. { Rect tempRect;
  348.   short tempItem;
  349.   Handle tempHandle;
  350.   long tmp;
  351.   Str255 tStr;
  352.   GetDialogItem( esd, esdSize2Et, &tempItem, &tempHandle, &tempRect );
  353.   GetMenuItemText( popMenu4, sizeChoice4, tStr );
  354.   SetDialogItemText( tempHandle, tStr );
  355.   SelectDialogItemText( esd, esdSize2Et, 0, 32767 );
  356.   StringToNum( tStr, &tmp);
  357.   tsNewAlt.tsSize = tmp;
  358. }
  359.  
  360. /* font menu selection triggers update of size menu */
  361. static void doFont1( void )
  362. { Str255 tStr;
  363.   GetMenuItemText( popMenu1, fontChoice1, tStr );
  364.   GetFNum( tStr, &tsNewPri.tsFont );
  365.   if( popMenu3 ) DisposeHandle( (Handle )popMenu3 );
  366.   popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  367. }
  368.  
  369. /* font menu selection triggers update of size menu */
  370. static void doFont2( void )
  371. { Str255 tStr;
  372.   GetMenuItemText( popMenu2, fontChoice2, tStr );
  373.   GetFNum( tStr, &tsNewAlt.tsFont );
  374.   if( popMenu4 ) DisposeHandle( (Handle )popMenu4 );
  375.   popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  376. }
  377.  
  378. /* this function always returns a value between 1 and MAXFONTSIZE inclusive */
  379. /* an out of range number returns 8;
  380.    this is so font sizes and tab stops are reasonable */
  381. static long etToNum( DialogPtr dbox, short item )
  382. { short tempItem;
  383.   Rect tempRect;
  384.   Handle tempHandle;
  385.   long tmp;
  386.   Str255 tStr;
  387.   GetDialogItem( dbox, item, &tempItem, &tempHandle, &tempRect );
  388.   GetDialogItemText( tempHandle, tStr );
  389.   StringToNum( tStr, &tmp);
  390.   if( tmp > MAXFONTSIZE || tmp < 1 ) tmp = 8;
  391.   return tmp;
  392. }
  393.  
  394. /* update size menu if size edit text box changed */
  395. static void preSize1( DialogPtr esd )
  396. { long tmp;
  397.   tmp = etToNum( esd, esdSize1Et );
  398.   if( tsNewPri.tsSize != tmp )
  399.   { tsNewPri.tsSize = tmp;
  400.     if( popMenu3 ) DisposeHandle( (Handle )popMenu3 );
  401.     popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  402.   }
  403. }
  404.  
  405. /* update size menu if size edit text box changed */
  406. static void preSize2( DialogPtr esd )
  407. { long tmp;
  408.   tmp = etToNum( esd, esdSize2Et );
  409.   if( tsNewAlt.tsSize != tmp )
  410.   { tsNewAlt.tsSize = tmp;
  411.     if( popMenu4 ) DisposeHandle( (Handle )popMenu4 );
  412.     popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  413.   }
  414. }
  415.  
  416. pascal Boolean filterIt( DialogPtr esd, EventRecord *myDialogEvent, short *theDialogItem)
  417. { WindowPtr temp;
  418.   char theKey;
  419.   Boolean result = false;
  420.  
  421.   GetPort( &temp );
  422.   SetPort( esd );
  423.     
  424.   IBeamIt( esd ); /* make IBeam cursor when over the active edit line */
  425.     
  426.   /* do standard filtering for escape and return as OK and Cancel aliases */
  427.   /* invert the button in the dialog, so the user get's visual feedback */
  428.  
  429.   if ((myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey))
  430.   { theKey = myDialogEvent->message & charCodeMask;
  431.     if( (myDialogEvent->modifiers & (cmdKey|controlKey|optionKey)) == 0 )
  432.     { switch( theKey )
  433.       { case kReturnKey:
  434.         case kEnterKey:
  435.             *theDialogItem = esdOK;
  436.             pseudoClick( esd, esdOK );
  437.           SetPort(temp);
  438.           result = true;
  439.           break;
  440.         case kEscKey:
  441.           *theDialogItem = esdCancel;
  442.           pseudoClick( esd, esdCancel );
  443.           SetPort(temp);
  444.           result = true;
  445.           break;
  446.         case kTabKey:
  447.         case kBackSpace:
  448.         case kLeftArrow:
  449.         case kRightArrow:
  450.         case kUpArrow:
  451.         case kDownArrow:
  452.         case kDeleteKey:
  453.             break;
  454.         default:
  455.           /* filter out non-numeric keys */
  456.           if( theKey < 0x30 || theKey > 0x39 )
  457.           { SysBeep( 1 );
  458.             SetPort( temp );
  459.             result = true;
  460.           }
  461.           break;
  462.       }
  463.     }
  464.   }
  465.   else if( myDialogEvent->what == mouseDown )
  466.   { Point mouseLoc;
  467.     short newChoice;
  468.     mouseLoc = ( myDialogEvent->where );
  469.     GlobalToLocal( &mouseLoc );
  470.     switch( newChoice = FindDialogItem( esd, mouseLoc ) + 1 )
  471.     { case esdFont1St:
  472.       case esdFont1Pu:
  473.         InvertRect( &promptBox1 );
  474.         newChoice = doPop( esd, popMenu1, popUpBox1, popMenuID1, fontChoice1 );
  475.         InvertRect( &promptBox1 );
  476.         if( newChoice != 0 )
  477.         { fontChoice1 = newChoice;
  478.           DrawPopUp1( esd, esdFont1Pu );
  479.           *theDialogItem = esdFont1Pu;
  480.           SetPort( temp );
  481.           result = true;
  482.         }
  483.         break;
  484.       case esdFont2St:
  485.       case esdFont2Pu:
  486.         InvertRect( &promptBox2 );
  487.         newChoice = doPop( esd, popMenu2, popUpBox2, popMenuID2, fontChoice2 );
  488.         InvertRect( &promptBox2 );
  489.         if( newChoice != 0 )
  490.         { fontChoice2 = newChoice;
  491.           DrawPopUp2( esd, esdFont2Pu );
  492.           *theDialogItem = esdFont2Pu;
  493.           SetPort( temp );
  494.           result = true;
  495.         }
  496.         break;
  497.       /* case esdSize2St:  not for size menu!? */
  498.       case esdSize1Pu:
  499.           SelectDialogItemText( esd, esdSize1Et, 0, 32767 );
  500.           preSize1( esd );
  501.         newChoice = doPop( esd, popMenu3, popUpBox3, popMenuID3, sizeChoice3 );
  502.         if( newChoice != 0 )
  503.         { sizeChoice3 = newChoice;
  504.           DrawPopUpSz( esd, esdSize1Pu );
  505.           *theDialogItem = esdSize1Pu;
  506.           SetPort( temp );
  507.           result = true;
  508.         }
  509.         break;
  510.       /* case esdSize2St:  not for size menu!? */
  511.       case esdSize2Pu:
  512.           SelectDialogItemText( esd, esdSize2Et, 0, 32767 );
  513.           preSize2( esd );
  514.         newChoice = doPop( esd, popMenu4, popUpBox4, popMenuID4, sizeChoice4 );
  515.         if( newChoice != 0 )
  516.         { sizeChoice4 = newChoice;
  517.           DrawPopUpSz( esd, esdSize2Pu );
  518.           *theDialogItem = esdSize2Pu;
  519.           SetPort( temp );
  520.           result = true;
  521.         }
  522.         break;
  523.     }
  524.   }
  525.   return( result );
  526. }
  527.  
  528. static void check( DialogPtr dbox, short item, Boolean mark )
  529. { ControlHandle hC;
  530.   short itemtype;
  531.   Rect itemrect;    
  532.   GetDialogItem( dbox, item, &itemtype, (Handle *)&hC, &itemrect);
  533.   SetControlValue( hC, mark );
  534. }
  535.  
  536. static void checks( DialogPtr dbox, short style, short offs )
  537. {
  538.   check( dbox, esdBold1Cb + offs, ( style & bold ) ? 1 : 0 );
  539.   check( dbox, esdItal1Cb + offs, ( style & italic ) ? 1 : 0 );
  540.   check( dbox, esdUndr1Cb + offs, ( style & underline ) ? 1 : 0 );
  541.   check( dbox, esdCond1Cb + offs, ( style & condense ) ? 1 : 0 );
  542.   check( dbox, esdExpd1Cb + offs, ( style & extend ) ? 1 : 0 );
  543.   /*
  544.   check( dbox, esdInvr1Cb + offs, ( style & bold ) ? 1 : 0 );
  545.   */
  546. }
  547.  
  548. short checklist[] = { bold, italic, condense, underline, 0x80, extend };
  549.  
  550. static short findFontItem( MenuHandle hM, short fontNum )
  551. { short result = 1;
  552.   short i, fn;
  553.   Str255 tStr;
  554.   for( i = CountMItems( hM ); i > 0; i-- )
  555.   { GetMenuItemText( hM, i, tStr );
  556.     GetFNum( tStr, &fn );
  557.     if( fn == fontNum ) return i;
  558.     if( fn == 0 ) result = i;
  559.   }
  560.   return result;
  561. }
  562.  
  563. /* get the item's rect & set the procPtr */
  564. static void initUserItem( DialogPtr esd, short item, Rect *pRect, UserItemUPP pProc )
  565. { short tempItem;
  566.   Handle tempHandle;
  567.   GetDialogItem( esd, item, &tempItem, &tempHandle, pRect );
  568.   SetDialogItem( esd, item, tempItem, (Handle )pProc, pRect );
  569. }
  570.  
  571. static void hosePops( void )
  572. {
  573.   if( popMenu1 ) DisposeHandle( (Handle )popMenu1 );
  574.   popMenu1 = 0;
  575.   if( popMenu2 ) DisposeHandle( (Handle )popMenu2 );
  576.   popMenu2 = 0;
  577.   if( popMenu3 ) DisposeHandle( (Handle )popMenu3 );
  578.   popMenu3 = 0;
  579.   if( popMenu4 ) DisposeHandle( (Handle )popMenu4 );
  580.   popMenu4 = 0;
  581. }
  582.  
  583. static void initPops( DialogPtr esd )
  584. { Str255 tStr;
  585.   short tempItem;
  586.   Rect tempRect;
  587.   Handle tempHandle;
  588.  
  589.   hosePops();
  590.   
  591.   SetPort( esd );
  592.   
  593.   popMenu1 = NewMenu( popMenuID1, "\p" );
  594.   AppendResMenu( popMenu1, 'FONT' );
  595.   fontChoice1 = findFontItem( popMenu1, tsNewPri.tsFont );
  596.   SetItemMark( popMenu1, fontChoice1, checkMark );
  597.   InvalRect( &popUpBox1 );
  598.     
  599.   popMenu2 = NewMenu( popMenuID2, "\p" );
  600.   AppendResMenu( popMenu2, 'FONT' );
  601.   fontChoice2 = findFontItem( popMenu2, tsNewAlt.tsFont );
  602.   SetItemMark( popMenu2, fontChoice2, checkMark );
  603.   InvalRect( &popUpBox2 );
  604.   
  605.   popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  606.   doSize1( esd );
  607.  
  608.   popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  609.   doSize2( esd );
  610.   
  611.   checks( esd, tsNewPri.tsFace,  0 );
  612.   checks( esd, tsNewAlt.tsFace, 10 );
  613.   
  614.   NumToString( (long )tabsNew, tStr );
  615.   GetDialogItem( esd, esdTabsEt, &tempItem, &tempHandle, &tempRect );
  616.   SetDialogItemText( tempHandle, tStr );
  617.   SelectDialogItemText( esd, esdTabsEt, 0, 32767 );
  618.   
  619.   NumToString( (long )wrapNew, tStr );
  620.   GetDialogItem( esd, esdWrapEt, &tempItem, &tempHandle, &tempRect );
  621.   SetDialogItemText( tempHandle, tStr );
  622.   SelectDialogItemText( esd, esdWrapEt, 0, 32767 );
  623.  
  624.   check( esd, esdAutoInd, autoIndNew );
  625. }
  626.  
  627. static suppinit = 0;
  628. ModalFilterUPP filterItUPP;
  629. UserItemUPP DrawPopUp1UPP;
  630. UserItemUPP DrawPopUp2UPP;
  631. UserItemUPP DrawPopUpSzUPP;
  632. UserItemUPP OutlinerUPP;
  633. UserItemUPP BorderDefaultUPP;
  634.  
  635. void eStyleDlg( eRec **hE /* , TextStyle *pri, TextStyle *alt */ )
  636. { DialogPtr esd = NULL;
  637.   short hitItem = 0;
  638.   short tempItem;
  639.   Rect tempRect;
  640.   Handle tempHandle;
  641.   long tmp1, tmp2, tmp3;
  642.  
  643.   if ( ! suppinit )
  644.   { filterItUPP = NewModalFilterProc(filterIt);
  645.     DrawPopUp1UPP  = NewUserItemProc(DrawPopUp1);
  646.     DrawPopUp2UPP  = NewUserItemProc(DrawPopUp2);
  647.     DrawPopUpSzUPP = NewUserItemProc(DrawPopUpSz);
  648.     OutlinerUPP    = NewUserItemProc(Outliner);
  649.     BorderDefaultUPP = NewUserItemProc(BorderDefault);
  650.     suppinit = 1;
  651.   }
  652.   
  653.   tsNewPri = (**hE).style[0];
  654.   tsNewAlt = (**hE).style[1];
  655.   tabsNew = (**hE).tabStops;
  656.   wrapNew = (**hE).wrap;
  657.   autoIndNew = (**hE).autoInd;
  658.  
  659.   /* Get a dialog box, and set up our useritems */
  660.   esd = GetNewDialog( esdID, NULL, (WindowPtr)(-1) );
  661.         
  662.   /* Find out where our useritems are, and set their item handles to be
  663.      a pointer to our popup-drawing or other special procedure */
  664.   GetDialogItem( esd, esdFont1St, &tempItem, &tempHandle, &promptBox1 ); /* get the title rect */
  665.   initUserItem( esd, esdFont1Pu, &popUpBox1, DrawPopUp1UPP ); /* universal header kludge 7Jun94 e */
  666.   GetDialogItem( esd, esdFont2St, &tempItem, &tempHandle, &promptBox2 ); /* get the title rect */
  667.   initUserItem( esd, esdFont2Pu, &popUpBox2, DrawPopUp2UPP ); /* universal header kludge 7Jun94 e */
  668.   initUserItem( esd, esdSize1Pu, &popUpBox3, DrawPopUpSzUPP ); /* universal header kludge 7Jun94 e */
  669.   initUserItem( esd, esdSize2Pu, &popUpBox4, DrawPopUpSzUPP ); /* universal header kludge 7Jun94 e */
  670.   initUserItem( esd, esdOutline1, &tempRect, OutlinerUPP ); /* universal header kludge 7Jun94 e */
  671.   initUserItem( esd, esdOutline2, &tempRect, OutlinerUPP ); /* universal header kludge 7Jun94 e */
  672.   initUserItem( esd, esdOutline3, &tempRect, OutlinerUPP ); /* universal header kludge 7Jun94 e */
  673.  
  674.   GetDialogItem( esd, esdOK,&tempItem, &tempHandle, &tempRect ); /* get the OK button's rect */
  675.   InsetRect( &tempRect, -4, -4);
  676.   SetDialogItem( esd, esdOKring, userItem+itemDisable, (Handle )BorderDefaultUPP, &tempRect);
  677.  
  678.   /* Get two menus containing the current set of fonts */
  679.   /* and two menus containing their corresponding sizes */
  680.   initPops( esd );
  681.   
  682.   check( esd, esdThisCb, 1 );
  683.   check( esd, esdPrefCb, 0 );    /* defaulted to off  --  16Jul92  e  */
  684.     
  685.   ShowWindow( (WindowPtr)esd );
  686.   DrawDialog( esd );
  687.   do
  688.   { ModalDialog( filterItUPP, &hitItem );
  689.     switch ( hitItem )
  690.     { case esdFont1Pu:
  691.         doFont1( );
  692.         break;
  693.       case esdFont2Pu:
  694.         doFont2( );
  695.         break;
  696.       case esdSize1Pu:
  697.           doSize1( esd );
  698.         break;
  699.       case esdSize2Pu:
  700.           doSize2( esd );
  701.         break;
  702.       case esdBold1Cb:
  703.       case esdItal1Cb:
  704.       case esdCond1Cb:
  705.       case esdUndr1Cb:
  706.       case esdInvr1Cb:
  707.       case esdExpd1Cb:
  708.         GetDialogItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  709.         tempItem = GetControlValue( (ControlHandle )tempHandle ) ^ 1;
  710.         if( tempItem == 0 )
  711.           tsNewPri.tsFace &= ~checklist[hitItem-esdBold1Cb];
  712.         else
  713.           tsNewPri.tsFace |=  checklist[hitItem-esdBold1Cb];
  714.         SetControlValue( (ControlHandle )tempHandle, tempItem);
  715.         break;
  716.       case esdBold2Cb:
  717.       case esdItal2Cb:
  718.       case esdCond2Cb:
  719.       case esdUndr2Cb:
  720.       case esdInvr2Cb:
  721.       case esdExpd2Cb:
  722.         GetDialogItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  723.         tempItem = GetControlValue( (ControlHandle )tempHandle ) ^ 1;
  724.         if( tempItem == 0 )
  725.           tsNewAlt.tsFace &= ~checklist[hitItem-esdBold2Cb];
  726.         else
  727.           tsNewAlt.tsFace |=  checklist[hitItem-esdBold2Cb];
  728.         SetControlValue( (ControlHandle )tempHandle, tempItem);
  729.         break;
  730.       case esdThisCb:
  731.       case esdPrefCb:
  732.       case esdAutoInd:
  733.         GetDialogItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  734.         tempItem = GetControlValue( (ControlHandle )tempHandle ) ^ 1;
  735.         SetControlValue( (ControlHandle )tempHandle, tempItem);
  736.         break;
  737.       case esdThisBt:
  738.         tsNewPri = (**hE).style[0];
  739.         tsNewAlt = (**hE).style[1];
  740.         tabsNew =  (**hE).tabStops;
  741.         wrapNew =  (**hE).wrap;
  742.         autoIndNew = (**hE).autoInd;
  743.         initPops( esd );
  744.         break;
  745.       case esdPrefBt:
  746.         tsNewPri = prefStylNormal;
  747.         tsNewAlt = prefStylHilite;
  748.         tabsNew  = prefTabs;
  749.         wrapNew  = prefWrap;
  750.         autoIndNew = prefAutoInd;
  751.         initPops( esd );
  752.         break;
  753.       case esdDfltBt:
  754.         tsNewPri = dfltStylNormal;
  755.         tsNewAlt = dfltStylHilite;
  756.         tabsNew  = dfltTabs;
  757.         wrapNew  = dfltWrap;
  758.         autoIndNew = dfltAutoInd;
  759.         initPops( esd );
  760.         break;
  761.     }
  762.   } while ( hitItem != esdOK && hitItem != esdCancel );
  763.   
  764.   if( hitItem == esdOK )
  765.   { tsNewPri.tsSize = etToNum( esd, esdSize1Et );
  766.     tsNewAlt.tsSize = etToNum( esd, esdSize2Et );
  767.     tmp1 = etToNum( esd, esdTabsEt );
  768.     tmp2 = etToNum( esd, esdWrapEt );
  769.     GetDialogItem( esd, esdAutoInd, &tempItem, &tempHandle, &tempRect);
  770.     tmp3 = GetControlValue( (ControlHandle )tempHandle );
  771.     GetDialogItem( esd, esdThisCb, &tempItem, &tempHandle, &tempRect);
  772.     if( GetControlValue( (ControlHandle )tempHandle ) )
  773.     { if( (**hE).tabStops != tmp1 )
  774.       { eTeSetTabStop( hE, (short )tmp1 );
  775.       }
  776.       if( (**hE).wrap != tmp2 )
  777.       { eTeSetWrap( hE, (short )tmp2 );
  778.       }
  779.       (**hE).autoInd = tmp3;
  780.       if(    tsNewPri.tsFont != (**hE).style[0].tsFont
  781.           || tsNewPri.tsSize != (**hE).style[0].tsSize
  782.           || tsNewPri.tsFace != (**hE).style[0].tsFace
  783.           || tsNewAlt.tsFont != (**hE).style[1].tsFont
  784.           || tsNewAlt.tsSize != (**hE).style[1].tsSize
  785.           || tsNewAlt.tsFace != (**hE).style[1].tsFace
  786.         )
  787.       { eTeSetStyles( hE, &tsNewPri, &tsNewAlt );
  788.       }
  789.     }
  790.     GetDialogItem( esd, esdPrefCb, &tempItem, &tempHandle, &tempRect);
  791.     if( GetControlValue( (ControlHandle )tempHandle ) )
  792.     { prefStylNormal = tsNewPri;
  793.       prefStylHilite = tsNewAlt;
  794.       prefTabs    = (short )tmp1;
  795.       prefWrap    = (short )tmp2;
  796.       prefAutoInd = (short )tmp3;
  797.       savePrefs( PREFS_FILENAME );  /*  16Jul92  e  */
  798.     }
  799.   }
  800.   hosePops();
  801.   if( esd ) DisposeDialog( esd );
  802. }
  803.  
  804. /* end of os_mac_eStyle.c */
  805.